
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>let </title>
</head>
<body>
    
    <script>
        // js之父： 布兰登.艾克
        // ES6=ECMAScript2015

        // JS由三部分组成
        // DOM		document object model  文档对象模型          dom操作
        // BOM		浏览器对象模型     window                    混合开发      路由模式  history对象  
        // ECMAScript  语法 语义

        // 1. ECMAScript和JavaScript
        // - ECMA是标准，JS是实现
        //     - 类似于HTML5是标准，IE10、Chrome、FF都是实现
        //     - 换句话说，将来也能有其他XXXScript来实现ECMA
        // - ECMAScript简称ECMA或ES
        // - 目前版本
        //     - 低级浏览器主要支持ES 3.1 
        //     - 高级浏览器正在从ES 5过渡到ES6    ES12  ES13、


        // 2. 历史版本

        // |时间   |ECMA    |JS|解释|
        // |---|---|---|---|
        // |1996.11|ES 1.0|JS稳定|Netscape将JS提交给ECMA组织，ES正式出现|
        // |1998.06|ES 2.0||ES2正式发布|
        // |1999.12|ES 3.0||ES3被广泛支持|
        // |2007.10|ES 4.0||ES4过于激进，被废了|
        // |2008.07|ES 3.1||4.0退化为严重缩水版的3.1<br/>因为吵得太厉害，所以ES 3.1代号为Harmony(和谐)|
        // |2009.12|ES 5.0||ES 5.0正式发布<br/>同时公布了JavaScript.next也就是后来的ES 6.0|
        // |2011.06|ES 5.1||ES 5.1成为了ISO国际标准|
        // |2013.03|ES 6.0||ES 6.0草案定稿|
        // |2013.12|ES 6.0||ES 6.0草案发布|
        // |2015.06|ES 6.0||ES 6.0预计发布正式版<br/>JavaScript.next开始指向ES 7.0|


          // 1、什么是es6？
        // ECMAScript 6.0 的简称     ECMA-2015
        // 是 JavaScript 语言的下一代标准，
        // 已经在 2015 年 6 月正式发布了。

        // 1-1、 什么是ECMAScript？
        // ECMA 是制定js的标准化组织。
        // ECMAScript规定了浏览器脚本语言的标准。

        // 1-2、ECMAScript 和 javascript 关系？
        // ECMAScript是JavaScript的规格（标准）
        // JavaScript是ECMAScript的一种实现。

        // 1-3、语法提案的批准流程    政府提拔官员类似
        // Stage 0 - Strawman（展示阶段）
        // Stage 1 - Proposal（征求意见阶段）
        // Stage 2 - Draft（草案阶段） //查不多定了 可以用了
        // Stage 3 - Candidate（候选人阶段）
        // Stage 4 - Finished（定案阶段）

         // es6特点：  简洁、严谨
        // es6有哪些新特性：
        // 1:let const 块作用域

        // 2：解构赋值

        // 3：数组的扩展  字符串的扩展  对象的扩展 

        // 4：Set  Map 数据结构

        // 5：函数的扩展  箭头函数   函数的简洁表示法   尾调用

        // 6:Promise   generator  异步操作 async函数

        // 7:类与类的继承    class   extends

        // 8：模块化     export  import  module 

        // 9: 新增数据类型   Symbol

        // 10： Proxy代理与反射reflect




        // let   var  	定义变量     const定义常量
        // 1:let const  块作用域  var可以定义全局作用域也可以定义局部作用域
        
        // 特点：
        //     1.let不存在变量提升
        //     2.let在同一个作用域中不能重复声明，而var则可以
        //     3.let是块级作用域、而var声明的变量是函数作用域、但在if与for中声明的变量为全局作用域 
        //     4.存在暂时性死区:
        //         只要块级作用域内存在`let`命令，它所声明的变量就“绑定”这个区域，不再受外部的影响。
        //         在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”
        //     5.let声明的变量不会绑定到window对象上，var声明的变量会绑定到window对象上。 
        // 应用场景：
        //     dom批量绑定事件


        // for (var i = 0; i < 10; i++) {
        //    console.log("i=:"+i);//0-9
           
        // }

        // console.log("i=:"+i+"/");//10

        // for (let i = 0; i < 10; i++) {
        //    console.log("i=:"+i);//0-9
           
        // }
        // console.log("i=:"+i+"/");//10


        // {
        //     let  num1=100
        //     let  num2=200
        //     {
        //         console.log(num1);
        //         console.log(num2);  
        //     }   
        // }


        // var arr =  []
        // for (var i = 0; i < 10; i++) {
        //    arr[i] = function () {//异步
        //         console.log(i);   
        //    }  
        //     // arr[0] = function () {
        //     //      console.log(index)//
        //     // }  
        //     // arr[1] = function () {
        //     //      console.log(index)//
        //     // }  
        //     // ....
        //     // arr[9] = function () {
        //     //      console.log(index)//
        //     // } 
        // }

        // arr[0]()
        // arr[4]()
        // arr[7]()
        // arr[9]()



        // var arr =  []
        // for (let i = 0; i < 10; i++) {//块级作用域
        //    arr[i] = function () {//
        //         console.log(i);   
        //    }  
        //     // arr[0] = function () {
        //     //      console.log(index)//
        //     // }  
        //     // arr[1] = function () {
        //     //      console.log(index)//
        //     // }  
        //     // ....
        //     // arr[9] = function () {
        //     //      console.log(index)//
        //     // } 
        // }

        // arr[0]()
        // arr[4]()
        // arr[7]()
        // arr[9]()


        // 闭包来实现-绑定索引值

        var arr =  []
        for (var i = 0; i < 10; i++) {//块级作用域
           (function (index) {
               arr[i] = function () {//
                    console.log(index);   
               }  
           })(i)
           
        }

        arr[0]()
        arr[4]()
        arr[7]()
        arr[9]()

        // js预解析
        // console.log(num);//
        // var num = 100;
        // function num() {
        //     console.log("hello");
        // }


        // var  temp = 123;
        // if (true) {
        //     temp = "abc"
        //     console.log(temp);//报错
        //     let temp;//暂时性死区
        // }


        // { 
        //     {
        //         {
        //             let a=10;
        //         }
        //     }
        //     console.log(a)
        // };

        var  tmp = new Date()

        function fn() {//函数内重写进行js预解析
            console.log(tmp);//undefined
            if (true) {
                var tmp = "hello"
            }
        }

        fn()


    </script>
</body>
</html>